home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / editors / mjovesrc.zoo / proc.c < prev    next >
C/C++ Source or Header  |  1992-04-04  |  20KB  |  911 lines
  1. /***************************************************************************
  2.  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
  3.  * is provided to you without charge, and with no warranty.  You may give  *
  4.  * away copies of JOVE, including sources, provided that this notice is    *
  5.  * included in all the files.                                              *
  6.  ***************************************************************************/
  7.  
  8. #include "jove.h"
  9. #include "ctype.h"
  10. #include "fp.h"
  11. #include "re.h"
  12. #include "termcap.h"
  13. #include "disp.h"
  14. #include "rec.h"
  15.  
  16. #include <signal.h>
  17. #ifdef    STDARGS
  18. # include <stdarg.h>
  19. #else
  20. # include <varargs.h>
  21. #endif
  22.  
  23. #ifdef    MSDOS
  24. # include <io.h>
  25. # include <process.h>
  26. #endif
  27.  
  28. private void
  29.     DoShell proto((char *, char *)),
  30.     com_finish proto((int, char *));
  31.  
  32. long    SigMask = 0;
  33.  
  34. /* This disgusting RE search string parses output from the GREP
  35.    family, from the pdp11 compiler, pcc, and lint.  Jay (HACK)
  36.    Fenlasen changed this to work for the lint errors. */
  37. char    ErrFmtStr[256] = "^\\{\",\\}\\([^:\"( \t]*\\)\\{\"\\, line ,:,(\\} *\\([0-9][0-9]*\\)[:)]\
  38. \\|::  *\\([^(]*\\)(\\([0-9]*\\))$\
  39. \\|( \\([^(]*\\)(\\([0-9]*\\)) ),";
  40.  
  41. struct error {
  42.     Buffer        *er_buf;    /* Buffer error is in */
  43.     Line        *er_mess,    /* Actual error message */
  44.             *er_text;    /* Actual error */
  45.     int        er_char;    /* char pos of error */
  46.     struct error    *er_prev,    /* List of errors */
  47.             *er_next;
  48. };
  49.  
  50. private struct error    *cur_error = NULL,
  51.         *errorlist = NULL;
  52. Buffer        *perr_buf = NULL;    /* Buffer with error messages */
  53.  
  54. bool    WtOnMk = ON;        /* Write the modified files when we make */
  55.  
  56. /* Eliminate any error records that contain dangling references to Lines.
  57.  * We only eliminate error structs when either referent is recycled.
  58.  * If it deleted, we keep it (dormant) in case it will be pasted back
  59.  * into the same buffer.
  60.  */
  61.  
  62. void
  63. ChkErrorLines()
  64. {
  65.     register struct error    *e;
  66.     struct error    *prev = NULL;
  67.  
  68.     for (e = errorlist; e != NULL; ) {
  69.         struct error    *next = e->er_next;
  70.  
  71.         if (e->er_mess->l_dline == NULL_DADDR
  72.         || e->er_text->l_dline == NULL_DADDR)
  73.         {
  74.             /* dangling reference: delete */
  75.             if (prev == NULL)
  76.                 errorlist = next;
  77.             else
  78.                 prev->er_next = next;
  79.             if (next != NULL)
  80.                 next->er_prev = prev;
  81.             if (cur_error == e)
  82.                 cur_error = next;
  83.             free((UnivPtr)e);
  84.         } else {
  85.             prev = e;
  86.         }
  87.         e = next;
  88.     }
  89. }
  90.  
  91. /* Add an error to the end of the list of errors.  This is used for
  92.    parse-{C,LINT}-errors and for the spell-buffer command */
  93.  
  94. private struct error *
  95. AddError(laste, errline, buf, line, charpos)
  96. struct error    *laste;
  97. Line    *errline,
  98.     *line;
  99. Buffer    *buf;
  100. int    charpos;
  101. {
  102.     struct error    *new = (struct error *) emalloc(sizeof *new);
  103.  
  104.     new->er_prev = laste;
  105.     if (laste)
  106.         laste->er_next = new;
  107.     else {
  108.         if (errorlist)        /* Free up old errors */
  109.             ErrFree();
  110.         cur_error = errorlist = new;
  111.     }
  112.     laste = new;
  113.     new->er_next = NULL;
  114.     new->er_buf = buf;
  115.     new->er_text = line;
  116.     new->er_char = charpos;
  117.     new->er_mess = errline;
  118.  
  119.     return new;
  120. }
  121.  
  122. void
  123. get_FL_info(fname, lineno)
  124. char    *fname,
  125.     *lineno;
  126. {
  127.     putmatch(1, fname, (size_t)FILESIZE);
  128.     putmatch(2, lineno, (size_t)FILESIZE);
  129.  
  130.     /* error had lineno followed fname, so switch the two */
  131.     if (!jisdigit(lineno[0])) {
  132.         char    tmp[FILESIZE];
  133.  
  134.         strcpy(tmp, lineno);
  135.         strcpy(lineno, fname);
  136.         strcpy(fname, tmp);
  137.     }
  138. }
  139.  
  140. /* Free up all the errors */
  141.  
  142. void
  143. ErrFree()
  144. {
  145.     register struct error    *ep;
  146.  
  147.     for (ep = errorlist; ep != NULL; ep = ep->er_next)
  148.         free((UnivPtr) ep);
  149.     errorlist = cur_error = NULL;
  150. }
  151.  
  152. /* Parse errors of the form specified in ErrFmtStr in the current
  153.    buffer.  Do a show error of the first error.  This is neat because this
  154.    will work for any kind of output that prints a file name and a line
  155.    number on the same line. */
  156.  
  157. void
  158. ErrParse()
  159. {
  160.     struct RE_block    re_blk;
  161.     Bufpos    *bp;
  162.     char    fname[FILESIZE],
  163.         lineno[FILESIZE];
  164.     int    lnum,
  165.         last_lnum = -1;
  166.     struct error    *ep = NULL;
  167.     Buffer    *buf,
  168.         *lastb = NULL;
  169.     Line    *err_line;
  170.  
  171.     ErrFree();        /* This is important! */
  172.     ToFirst();
  173.     perr_buf = curbuf;
  174.     REcompile(ErrFmtStr, YES, &re_blk);
  175.     /* Find a line with a number on it. */
  176.     while ((bp = docompiled(FORWARD, &re_blk)) != NULL) {
  177.         SetDot(bp);
  178.         get_FL_info(fname, lineno);
  179.         buf = do_find((Window *)NULL, fname, YES);
  180.         if (buf != lastb) {
  181.             lastb = buf;
  182.             last_lnum = -1;        /* signals new file */
  183.             err_line = buf->b_first;
  184.         }
  185.         (void) chr_to_int(lineno, 10, NO, &lnum);
  186.         if (lnum == last_lnum)    /* one error per line is nicer */
  187.             continue;
  188.         if (last_lnum == -1)
  189.             last_lnum = 1;    /* that's where we really are */
  190.         err_line = next_line(err_line, lnum - last_lnum);
  191.         ep = AddError(ep, curline, buf, err_line, 0);
  192.         last_lnum = lnum;
  193.     }
  194.     if (cur_error != NULL)
  195.         ShowErr();
  196. }
  197.  
  198. private void
  199. NeedErrors()
  200. {
  201.     if (cur_error == NULL)
  202.         complain("No errors!");
  203. }
  204.  
  205. private bool
  206. ErrorHasReferents()
  207. {
  208.     return inlist(cur_error->er_buf->b_first, cur_error->er_text)
  209.         && inlist(perr_buf->b_first, cur_error->er_mess);
  210. }
  211.  
  212. /* Go the the next error, if there is one.  Put the error buffer in
  213.    one window and the buffer with the error in another window.
  214.    It checks to make sure that the error actually exists. */
  215.  
  216. private void
  217. ToError(forward)
  218. bool    forward;
  219. {
  220.     register struct error    *e = cur_error;
  221.     int    num = arg_value();
  222.  
  223.     NeedErrors();
  224.     if ((forward? e->er_next : e->er_prev) == NULL)
  225.         complain("You're at the %s error.", forward ? "last" : "first");
  226.     while (--num >= 0 || !ErrorHasReferents()) {
  227.         e = forward ? e->er_next : e->er_prev;
  228.         if (e == NULL)
  229.             break;
  230.         cur_error = e;
  231.     }
  232.     ShowErr();
  233. }
  234.  
  235. void
  236. NextError()
  237. {
  238.     ToError(TRUE);
  239. }
  240.  
  241. void
  242. PrevError()
  243. {
  244.     ToError(FALSE);
  245. }
  246.  
  247. int    EWSize = 20;    /* percentage of screen the error window
  248.                should be */
  249.  
  250. private void
  251. set_wsize(wsize)
  252. int    wsize;
  253. {
  254.     wsize = (LI * wsize) / 100;
  255.     if (wsize >= 1 && !one_windp())
  256.         WindSize(curwind, wsize - (curwind->w_height - 1));
  257. }
  258.  
  259. /* Show the current error, i.e. put the line containing the error message
  260.    in one window, and the buffer containing the actual error in another
  261.    window. */
  262.  
  263. void
  264. ShowErr()
  265. {
  266.     Window    *err_wind,
  267.         *buf_wind;
  268.  
  269.     NeedErrors();
  270.     if (!ErrorHasReferents()) {
  271.         rbell();
  272.         return;
  273.     }
  274.     err_wind = windbp(perr_buf);
  275.     buf_wind = windbp(cur_error->er_buf);
  276.  
  277.     if (err_wind && !buf_wind) {
  278.         SetWind(err_wind);
  279.         pop_wind(cur_error->er_buf->b_name, NO, -1);
  280.         buf_wind = curwind;
  281.     } else if (!err_wind && buf_wind) {
  282.         SetWind(buf_wind);
  283.         pop_wind(perr_buf->b_name, NO, -1);
  284.         err_wind = curwind;
  285.     } else if (!err_wind && !buf_wind) {
  286.         pop_wind(perr_buf->b_name, NO, -1);
  287.         err_wind = curwind;
  288.         pop_wind(cur_error->er_buf->b_name, NO, -1);
  289.         buf_wind = curwind;
  290.     }
  291.  
  292.     /* Put the current error message at the top of its Window */
  293.     SetWind(err_wind);
  294.     SetLine(cur_error->er_mess);
  295.     SetTop(curwind, (curwind->w_line = cur_error->er_mess));
  296.     set_wsize(EWSize);
  297.  
  298.     /* now go to the the line with the error in the other window */
  299.     SetWind(buf_wind);
  300.     DotTo(cur_error->er_text, cur_error->er_char);
  301. }
  302.  
  303. char    ShcomBuf[LBSIZE];
  304.  
  305. /* Make a buffer name given the command `command', i.e. "fgrep -n foo *.c"
  306.    will return the buffer name "fgrep".  */
  307.  
  308. char *
  309. MakeName(command)
  310. char    *command;
  311. {
  312.     static char    bnm[50];
  313.     register char    *cp = bnm,
  314.             c;
  315.  
  316.     do ; while ((c = *command++) != '\0' && (c == ' ' || c == '\t'));
  317.     do {
  318.         *cp++ = c;
  319.     } while ((c = *command++) != '\0' && (c != ' ' && c != '\t'));
  320.     *cp = '\0';
  321.     strcpy(bnm, basename(bnm));
  322.  
  323.     return bnm;
  324. }
  325.  
  326. /* Run make, first writing all the modified buffers (if the WtOnMk flag is
  327.    on), parse the errors, and go the first error. */
  328.  
  329. private char    make_cmd[LBSIZE] = "make";
  330.  
  331. void
  332. MakeErrors()
  333. {
  334.     Window    *old = curwind;
  335.     int    status;
  336.     bool    compilation;
  337. #ifdef MiNT
  338. #include <ioctl.h>
  339.     struct sgttyb sg;
  340.     int tfd, set;
  341. #endif /* MiNT */
  342.  
  343.     if (WtOnMk)
  344.         put_bufs(FALSE);
  345.     /* When we're not doing make or cc (i.e., the last command
  346.        was probably a grep or something) and the user just types
  347.        C-X C-E, he probably (possibly, hopefully, usually (in my
  348.        case)) doesn't want to do the grep again but rather wants
  349.        to do a make again; so we ring the bell and insert the
  350.        default command and let the person decide. */
  351.  
  352.     compilation = (sindex("make", make_cmd) || sindex("cc", make_cmd));
  353.     if (is_an_arg() || !comp